This untangles two concerns that were awkwardly mashed together: "what can simulate" vs. "what can solve." The old Equation / EquationPriv / EquationTypes / EqnKind stack tried to cover both at once, which meant adding a new backend always came with copy-paste and fighting the trait hierarchy.

The replacement is four traits living in a new core module, each with one job:

• Solver — how state moves through time. You must implement solve(), process_observation(), and initial_state(). Batch solvers (like diffsol) also set is_batch() to true and manage events themselves.

• ModelInfo — what the model looks like. You must implement lag() and fa() (both return the backend's own closures). nstates(), ndrugs(), nout(), and metadata() are free.

• Caching — where prediction and error-model caches live. You must implement nothing. All five methods (prediction_cache(), error_model_cache(), with_cache_capacity(), without_cache(), clear_cache()) are free.

• Simulate — the user-facing API. You must implement simulate_subject() (for standard per-event backends that's just standard_event_loop::<Self, _>(self, ...)) and kind(). predictions(), log_likelihood(), and estimate_predictions() are free default methods on the trait.

There's also a shared ModelCore<C> struct that owns dimensions, metadata, and both caches so ODE, Analytical, and SDE don't each reimplement the same builder and invalidation dance. State, Predictions, and the metadata module moved into core/ alongside everything else. simulator/equation/ became simulator/backends/.

This is how adding a new solver loos like:

impl Solver for MyBackend { /* must: solve, process_observation, initial_state */ }
impl ModelInfo for MyBackend { /* must: lag, fa — free: nstates, ndrugs, nout, metadata */ }
impl Caching for MyBackend { /* free: all 5 methods */ }
impl Simulate for MyBackend {
    fn simulate_subject(...) { standard_event_loop::<Self, _>(self, ...) }
    fn kind() -> ModelKind { ... }
}

On my tests there are no regressions in performance.